package com.js.rtu.util;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Locale;

/**
 * 蓝牙收发工具
 * Created by wz on 2020/6/16.
 */
public class BleUtils {
    private  static boolean isRuning=false;
    private final static String mHexStr = "0123456789ABCDEF";

//    /**
//     * 发送指令
//     *
//     * @param message      指令
//     * @param callback     回调
//     */
//    public static void send(String message, onCallback callback) {
//        send(message , CmdConfig.TIME_OUT,callback);
//        EventBus.getDefault().post(new DebugWriteBean(message));
//    }
//    /**
//     * 发送指令
//     *
//     * @param message      指令
//     * @param milliseconds 超时时间
//     * @param callback     回调
//     */
//    public static void send(String message, int milliseconds, onCallback callback) {
//        if (RTUApplication.bluetoothSocket == null) {
//            callback.onFail("请先连接设备");
//            ToastUtil.info("请先连接设备");
//            return;
//        }
//        if (isRuning){
//            ToastUtil.info("正在处理，请不要多次点击");
//            return;
//        }
//        isRuning=true;
//        RxTimerUtil timerUtil = new RxTimerUtil();
//        timerUtil.timer(milliseconds * 1000, new RxTimerUtil.IRxNext() {
//            @Override
//            public void doNext(long number) {
//                callback.onFail("超时");
//                isRuning=false;
//            }
//        });
//
//       Observable.create(new ObservableOnSubscribe<String>() {
//            @Override
//            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
//                String[] data = message.split(" ");
//                byte[] tmp = new byte[data.length];
//                for (int i = 0; i < data.length; i++) {
//                    tmp[i] = (byte) Integer.parseInt(data[i], 16);
//                }
//                OutputStream outputStream = RTUApplication.bluetoothSocket.getOutputStream();
//                outputStream.write(tmp);
//                Log.e("xxxx", "发送：" + message);
//                InputStream inputStream = RTUApplication.bluetoothSocket.getInputStream();
//                byte[] buffer = new byte[1024];
//                StringBuilder stringBuilder = new StringBuilder();
//                int len;
//                while ((len = inputStream.read(buffer)) != -1) {
//                    Log.e("xxxx", "datalength:" + len);
//
//                    for (int i = 0; i < len; i++) {
//                        //hex2String,单位数的补0
//                        stringBuilder.append(int2hexString(buffer[i] ));
////                        stringBuilder.append( numToHex16(buffer[i]& 0xFF ));
//
////                        Log.e("xxxxxx",   numToHex16(buffer[i]& 0xFF ));
//                        stringBuilder.append(' ');
//                    }
//                    Log.e("xxxx", "receive:" + stringBuilder.toString());
//                    if (stringBuilder.toString().startsWith("EE EE")
//                            && stringBuilder.toString().endsWith("FF FF ")) {
//                        emitter.onNext(stringBuilder.toString());
//                        Log.e("xxxx", "回调:" + stringBuilder.toString());
//                        MyLog.i("onReceive",stringBuilder.toString());
//                        break;
//                    }
//
//                }
//            }
//        })
//
//                .subscribeOn(Schedulers.io())
//                .observeOn(AndroidSchedulers.mainThread())
//                .subscribe(new Observer<String>() {
//                    @Override
//                    public void onSubscribe(Disposable d) {
//                        MyLog.i("send",message);
//                    }
//
//                    @Override
//                    public void onNext(String s) {
//                        //crc校验
//                        if (CRC16Util.iscrc(s)){
//                            String[] data= s.split(" ");
//                            if (data[12].equals("FE")){
//                                callback.onFail("指令"+data[13]+"错误，"+ErrConfig.getErr(Integer.parseInt(data[14])));
//                            }else {
//                                callback.onReceive(s);
//                            }
//
//                        }else {
//                            callback.onFail("crc校验失败");
//                        }
//                        isRuning=false;
//
//                        timerUtil.cancel();
//                    }
//
//                    @Override
//                    public void onError(Throwable e) {
//                        callback.onFail(e.toString());
//                    }
//
//                    @Override
//                    public void onComplete() {
//
//                    }
//                });
//
//
//    }

    /**
     * 10进制转16,自动补0
     *1个byte型的单字节十六进制
     * @param number
     * @return
     */
    private static String int2hexString(int number) {
        return Integer.toHexString((number & 0x000000ff) | 0xffffff00)
                .substring(6).toUpperCase();
    }
    /**
     * 10进制转16,自动补0,大写
     *1个byte型的单字节十六进制
     * @param number
     * @return
     */
public static String numToHex16(int number) {
    return String.format("%02x", number).toUpperCase();
}
    public interface onCallback {
        void onReceive(String msg);

        void onFail(String err);
    }


    /**
     * 十六进制字符串转换成 ASCII字符串
     *
     * @param hexStr Byte字符串
     * @return String 对应的字符串
     */
    public static String hexStr2Str(String hexStr) {
        //00代表空字符
        hexStr = hexStr.toString().trim().replace("00", "").toUpperCase(Locale.US);
        hexStr = hexStr.toString().trim().replace(" ", "").toUpperCase(Locale.US);
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int iTmp = 0x00;

        for (int i = 0; i < bytes.length; i++) {
            iTmp = mHexStr.indexOf(hexs[2 * i]) << 4;
            iTmp |= mHexStr.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (iTmp & 0xFF);
        }
        return new String(bytes);
    }

    /**
     * 16->10
     * @param str
     * @return
     */
    public static int hToint(String str) {
            if (!str.isEmpty()){
            return Integer.parseInt(str, 16);
        }else{
                return 0;
        }

    }


    /**
     * bytes字符串转换为Byte值
     * @param src String Byte字符串，每个Byte之间没有分隔符(字符范围:0-9 A-F)
     * @return byte[]
     */
    public static byte[] hexStr2Bytes(String src){
        /*对输入值进行规范化整理*/
        src = src.trim().replace(" ", "").toUpperCase(Locale.US);
        //处理值初始化
        int m=0,n=0;
        int iLen=src.length()/2; //计算长度
        byte[] ret = new byte[iLen]; //分配存储空间

        for (int i = 0; i < iLen; i++){
            m=i*2+1;
            n=m+1;
            ret[i] = (byte)(Integer.decode("0x"+ src.substring(i*2, m) + src.substring(m,n)) & 0xFF);
        }
        return ret;
    }


    /**
     * 将一个int数字转换为二进制的字符串形式。
     * @param num 需要转换的int类型数据
     * @param digits 要转换的二进制位数，位数不足则在前面补0
     * @return 二进制的字符串形式
     */
    public static String toBinary(int num, int digits) {
        String cover = Integer.toBinaryString(1 << digits).substring(1);
        String s = Integer.toBinaryString(num);
        return s.length() < digits ? cover.substring(s.length()) + s : s;
    }

    /**
     * Float 转4字节浮点数
     * @param data 字节浮点数
     * @return
     */
    public static   String  getFloat(Float data){
        ByteBuffer byteBuffer = ByteBuffer.allocate(4);
        byteBuffer.order(ByteOrder.LITTLE_ENDIAN);//小端
        byteBuffer.putFloat(data);
        byte[] bytes = byteBuffer.array();
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return  sb.substring(0,sb.length()-1);
    }


    /**
     * 返回的浮点数格式的数据-->4字节浮点数，低在前
     * @param str 4字节数据
     * @return
     */
    public static   String  byte2Float(String str){
        //先转byte
        byte[] data =hexStr2Bytes(str);
        ByteBuffer buf = ByteBuffer.allocateDirect(4); //无额外内存的直接缓存
        buf.put(data);
        buf.rewind();
        str=String.valueOf(buf.getFloat());
        buf.clear();
        return str;
    }


    /**

     * 将字符串转成ASCII值
     */
    public static String strToASCII(String data) {
        String requestStr = "";
        for (int i = 0; i < data.length(); i++) {
            char a = data.charAt(i);
            int aInt = (int) a;
            requestStr = requestStr + integerToHexString(aInt);
        }
        return requestStr;
    }

    /**
     * 将十进制整数转为十六进制数，并补位
     * */
    public static String integerToHexString(int s) {
        String ss = Integer.toHexString(s);
        if (ss.length() % 2 != 0) {
            ss = "0" + ss;//0F格式
        }
        return ss.toUpperCase();
    }


}
